const express = require('express');
const router = express.Router();
const md5=require('md5')
const User=require('../../models/User')
const jwt=require('jsonwebtoken')
const multer = require('multer');
const path = require('path');
const Notice=require('../../models/Notice')
const mongoose=require('mongoose')

const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/avatars/');
  },
  filename: function (req, file, cb) {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, req.user.id + '-' + uniqueSuffix + path.extname(file.originalname));
  }
});

const upload = multer({ 
  storage: storage,
  limits: {
    fileSize: 2 * 1024 * 1024 // 2MB限制
  },
  fileFilter: function (req, file, cb) {
    if (file.mimetype.startsWith('image/')) {
      cb(null, true);
    } else {
      cb(new Error('只允许上传图片文件'), false);
    }
  }
});


const authenticateToken = (req, res, next) => {
  const authHeader = req.headers['authorization']
  const token = authHeader && authHeader.split(' ')[1] // Bearer TOKEN

  if (!token) {
    return res.json({
      code: '2006',
      msg: '访问被拒绝，未提供token',
      data: null
    })
  }

  try {
    const verified = jwt.verify(token, 'my_secret')
    req.user = verified
    next()
  } catch (err) {
    return res.json({
      code: '2007',
      msg: '无效的token',
      data: null
    })
  }
}

router.post('/reg', async (req, res) => {
  try {
    const { username, password } = req.body;
    // 1. 基础参数校验
    if (!username) {
      return res.json({
        code: '2003',
        msg: '用户名不能为空',
        data: null
      });
    }
    if (!password) {
      return res.json({
        code: '2004',
        msg: '密码不能为空',
        data: null
      });
    }

    // 2. 检查用户名是否已存在（避免重复注册）
    const existingUser = await User.findOne({ username });
    if (existingUser) {
      return res.json({
        code: '2005',
        msg: '用户名已被注册，请更换',
        data: null
      });
    }

    // 3. 处理用户数据（密码加密）
    const data = {
      username, // 强制使用用户输入的用户名（移除默认admin，避免冲突）
      password: md5(password) // 强制加密用户输入的密码（移除默认密码，提升安全性）
    };

    // 4. 创建用户并返回成功响应
    await User.create(data);
    res.json({
      code: '0000',
      msg: '注册成功',
      data: null // 注册成功无需返回敏感信息
    });

  } catch (err) {
    // 统一错误响应格式（与login接口一致）
    res.json({
      code: '2001',
      msg: '注册失败：' + err.message,
      data: null
    });
  }
});

router.post('/login',async (req, res) => {
  try {
    const { username, password } = req.body;
    const encryptedPwd = md5(password); // 加密密码（和注册时保持一致）

    // 查询用户
    const user = await User.findOne({ username, password: encryptedPwd });

    if (user) {
      let token=jwt.sign({
        id:user._id,
        username:user.username
      },'my_secret',{expiresIn:60*60*24*1})//1天过期
      res.json({
        code:'0000',
        msg:'登录成功',
        data:token
      })
    } else {
      // 用户名或密码错误，跳回登录页并提示
      return res.json({
        code:'2002',
        msg:'用户名或密码错误',
        data:null
      })
    }
  } catch (err) {
    res.status(500).send('登录失败：' + err.message);
    res.json({
      code:'2001',
      msg:'数据库读取失败'+err.message,
      data:null
    })
  }
});

router.get('/my/userinfo', authenticateToken, async (req, res) => {
  try {
    // 从 token 中获取用户ID
    const userId = req.user.id;
    
    // 查询用户信息，排除密码字段
    const user = await User.findById(userId).select('-password');
    
    if (!user) {
      return res.json({
        code: '2008',
        msg: '用户不存在',
        data: null
      });
    }
    
    res.json({
      code: '0000',
      msg: '获取用户信息成功',
      data: {
        id: user._id,
        username: user.username,
        nickname: user.nickname,
        email: user.email,
        avatar: user.avatar 
        // 如果有其他字段也可以在这里返回
        // email: user.email,
        // avatar: user.avatar,
        // 等等...
      }
    });
  } catch (err) {
    res.json({
      code: '2001',
      msg: '获取用户信息失败: ' + err.message,
      data: null
    });
  }
});

// 更新用户信息接口 - 新增
router.put('/my/userinfo', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const { nickname, email } = req.body;
    
    // 更新用户信息
    const updatedUser = await User.findByIdAndUpdate(
      userId,
      { nickname, email },
      { new: true } // 返回更新后的文档
    ).select('-password');
    
    if (!updatedUser) {
      return res.json({
        code: '2008',
        msg: '用户不存在',
        data: null
      });
    }
    
    res.json({
      code: '0000',
      msg: '更新用户信息成功',
      data: updatedUser
    });
  } catch (err) {
    res.json({
      code: '2001',
      msg: '更新用户信息失败: ' + err.message,
      data: null
    });
  }
});

// 更新用户头像接口 
router.patch('/my/update/avatar', authenticateToken, upload.single('avatar'), async (req, res) => {
  try {
    console.log('🔧 收到头像更新请求');
    console.log('📁 文件信息:', req.file);
    console.log('👤 用户信息:', req.user);
    
    if (!req.file) {
      console.log('❌ 未收到文件');
      return res.json({
        code: '2011',
        msg: '请选择头像文件',
        data: null
      });
    }
    
    const userId = req.user.id;
    const user = await User.findById(userId);
    
    if (!user) {
      return res.json({
        code: '2008',
        msg: '用户不存在',
        data: null
      });
    }
    
    // 生成头像URL
    const avatarUrl = `http://localhost:3000/uploads/avatars/${req.file.filename}`;
    
    // 更新用户头像
    user.avatar = avatarUrl;
    await user.save();
    
    console.log('✅ 头像更新成功:', avatarUrl);
    
    res.json({
      code: '0000',
      msg: '头像更新成功',
      data: { avatar: avatarUrl }
    });
    
  } catch (err) {
    console.error('❌ 头像更新失败:', err);
    res.json({
      code: '2001',
      msg: '头像更新失败: ' + err.message,
      data: null
    });
  }
});
// 更新密码接口 - 新增
router.patch('/my/updatepwd', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const { old_pwd, new_pwd, re_pwd } = req.body;
    
    // 验证新密码和确认密码是否一致
    if (new_pwd !== re_pwd) {
      return res.json({
        code: '2009',
        msg: '新密码和确认密码不一致',
        data: null
      });
    }
    
    // 获取用户当前信息
    const user = await User.findById(userId);
    if (!user) {
      return res.json({
        code: '2008',
        msg: '用户不存在',
        data: null
      });
    }
    
    // 验证旧密码是否正确
    if (user.password !== md5(old_pwd)) {
      return res.json({
        code: '2010',
        msg: '旧密码错误',
        data: null
      });
    }
    
    // 更新密码
    user.password = md5(new_pwd);
    await user.save();
    
    res.json({
      code: '0000',
      msg: '密码更新成功',
      data: null
    });
  } catch (err) {
    res.json({
      code: '2001',
      msg: '密码更新失败: ' + err.message,
      data: null
    });
  }
});

//退出登录
router.post('/logout',function(req, res, next) {
  req.session.destroy(()=>{
      res.render('success',{message:'退出成功',url:'/login',msg:'返回登录'})
  })
});

//获取该平台公告列表
router.get('/my/getNoticeList', authenticateToken, async (req, res) => {
  try {
    // 1. 接收前端请求参数（分页+可选筛选）
    const { 
      page = 1, // 页码，默认第1页
      limit = 10, // 每页条数，默认10条
      tag = '' // 可选：按标签筛选（如“系统通知”）
    } = req.query;

    // 2. 构建查询条件：仅筛选 object = "管理后台" 的公告
    const queryCondition = {
      object: '作家助手' // 固定筛选管理后台对应的公告
    };
    // 可选：添加标签筛选（若前端传了tag参数）
    if (tag && tag.trim() !== '') {
      queryCondition.tag = tag.trim();
    }

    // 3. 数据库查询（分页+排序+关联创建人昵称）
    const skip = (page - 1) * limit; // 计算跳过的条数
    const noticeList = await Notice.find(queryCondition)
      .populate({
        path: 'creatorId', // 关联创建人（Admin模型）
        model: 'Admin',
        select: 'nickname' // 仅获取昵称，避免敏感信息
      })
      .sort({ publishTime: -1 }) // 按发布时间倒序（最新公告在前）
      .skip(skip)
      .limit(Number(limit))
      .select('-__v'); // 排除MongoDB默认的__v字段

    // 4. 查询总条数（用于前端分页计算）
    const total = await Notice.countDocuments(queryCondition);

    // 5. 格式化响应数据（隐藏冗余字段，优化前端使用）
    const formattedList = noticeList.map(notice => ({
      id: notice._id.toString(), // 公告ID（字符串格式，便于前端存储）
      title: notice.title, // 公告标题
      content: notice.content || '', // 公告内容（默认空字符串）
      tag: notice.tag || '无标签', // 标签（默认“无标签”）
      object: notice.object, // 对象平台（固定为“管理后台”）
      publishTime: notice.publishTime, // 发布时间
      creatorName: notice.creatorId?.nickname || '未知管理员' // 创建人昵称（关联查询）
    }));

    // 6. 统一响应格式（与创建公告接口一致）
    res.json({
      code: '0000',
      msg: '获取管理后台公告列表成功',
      data: {
        list: formattedList, // 公告列表
        pagination: {
          total, // 总条数
          page: Number(page), // 当前页码
          limit: Number(limit), // 每页条数
          totalPages: Math.ceil(total / limit) // 总页数（可选，方便前端计算）
        }
      }
    });

  } catch (err) {
    // 异常处理：打印错误+统一错误响应
    console.error('获取管理后台公告列表失败：', err);
    res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {
        list: [],
        pagination: { total: 0, page: 1, limit: 10, totalPages: 0 }
      }
    });
  }
});

// 获取单个公告详情
router.get('/my/getNoticeInfo', authenticateToken, async (req, res) => {
  try {
    const noticeId = req.query.id; // 从查询参数获取ID

    // 验证格式
    if (!mongoose.Types.ObjectId.isValid(noticeId)) {
      return res.json({
        code: '2005',
        msg: 'ID格式错误',
        data: null
      });
    }

    // 查询详情（确保只能查询自己的小说）
    const notice = await Notice.findOne({ 
      _id: noticeId, 
    }).select('-__v');

    if (!notice) {
      return res.json({
        code: '2004',
        msg: '更改不存在或无权限查看',
        data: null
      });
    }

    res.json({
      code: '0000',
      msg: '获取公告详情成功',
      data: {
        id: notice._id,
        title:notice.title,
        content:notice.content,
        tag:notice.tag,
        publishTime:notice.publishTime
      }
    });

  } catch (err) {
    res.json({
      code: '2001',
      msg: '获取公告详情失败: ' + err.message,
      data: null
    });
  }
});
module.exports = router;
